/**
 * 组件扫描器
 * 用于扫描和注册组件目录结构
 */

import { ElMessage } from 'element-plus';
import autoComponentLoader from '@/services/AutoComponentLoader';
import { ref } from 'vue';

// 组件状态
export const componentScanStatus = ref({
  scanning: false,
  lastScanTime: null,
  componentCount: 0,
  componentWithSSRCount: 0,
  error: null
});

// 组件文件模式
const COMPONENT_PATTERNS = {
  index: 'index.vue',      // 组件主文件
  config: 'config.js',     // 组件配置文件
  export: 'export.js',     // 导出处理文件
  exportSSR: 'export.ssr.js', // SSR导出处理文件
  editor: 'editor.vue',    // 编辑器组件
  preview: 'preview.js'    // 预览处理文件
};

/**
 * 扫描并注册组件
 * 刷新组件映射表，同步状态
 * @returns {Promise<boolean>} 是否成功
 */
export async function scanAndRegisterComponents() {
  try {
    componentScanStatus.value.scanning = true;
    componentScanStatus.value.error = null;
    
    console.log('[ComponentScanner] 开始扫描组件...');
    const success = await autoComponentLoader.refreshComponentMapping();
    
    if (success) {
      componentScanStatus.value.lastScanTime = new Date();
      componentScanStatus.value.componentCount = autoComponentLoader.componentMap.size;
      
      // 计算支持SSR导出的组件数量
      let ssrCount = 0;
      for (const type of Array.from(autoComponentLoader.componentMap.keys())) {
        const componentPath = autoComponentLoader.resolveComponentPath(type);
        if (componentPath) {
          try {
            // 尝试检测组件是否有SSR导出文件
            await import(/* @vite-ignore */ `../components/library/${componentPath}/export.ssr.js`);
            ssrCount++;
          } catch (e) {
            // 不支持SSR导出，忽略错误
          }
        }
      }
      
      componentScanStatus.value.componentWithSSRCount = ssrCount;
      
      ElMessage.success(`组件扫描完成：共${componentScanStatus.value.componentCount}个组件，${ssrCount}个支持SSR导出`);
      console.log(`[ComponentScanner] 组件扫描完成: ${componentScanStatus.value.componentCount}个组件，${ssrCount}个支持SSR导出`);
    } else {
      componentScanStatus.value.error = '组件扫描失败';
      ElMessage.error('组件扫描失败');
      console.error('[ComponentScanner] 组件扫描失败');
    }
    
    return success;
  } catch (error) {
    componentScanStatus.value.error = `组件扫描出错: ${error.message}`;
    ElMessage.error(`组件扫描出错: ${error.message}`);
    console.error('[ComponentScanner] 组件扫描出错:', error);
    return false;
  } finally {
    componentScanStatus.value.scanning = false;
  }
}

/**
 * 验证组件目录结构是否符合规范
 * @param {string} path 组件目录路径
 * @returns {Promise<{valid: boolean, missing: string[], message: string}>} 验证结果
 */
export async function validateComponentDirectory(path) {
  try {
    const requiredFiles = [
      COMPONENT_PATTERNS.index, 
      COMPONENT_PATTERNS.config,
      COMPONENT_PATTERNS.export
    ];
    
    const optionalFiles = [
      COMPONENT_PATTERNS.exportSSR,
      COMPONENT_PATTERNS.editor,
      COMPONENT_PATTERNS.preview
    ];
    
    const missing = [];
    let valid = true;
    let hasSSRExport = false;
    
    // 检查必要文件
    for (const file of requiredFiles) {
      try {
        const exists = await checkFileExists(`${path}/${file}`);
        if (!exists) {
          missing.push(file);
          valid = false;
        }
      } catch (e) {
        missing.push(file);
        valid = false;
      }
    }
    
    // 检查可选文件，包括SSR导出
    for (const file of optionalFiles) {
      try {
        const exists = await checkFileExists(`${path}/${file}`);
        if (exists && file === COMPONENT_PATTERNS.exportSSR) {
          hasSSRExport = true;
        }
      } catch (e) {
        // 可选文件不影响验证结果
      }
    }
    
    return {
      valid,
      missing,
      hasSSRExport,
      message: valid 
        ? `组件目录结构验证通过${hasSSRExport ? '，支持SSR导出' : ''}`
        : `组件目录结构缺少必要文件: ${missing.join(', ')}`
    };
  } catch (error) {
    return {
      valid: false,
      missing: [],
      hasSSRExport: false,
      message: `组件目录验证出错: ${error.message}`
    };
  }
}

/**
 * 检查文件是否存在
 * @param {string} filePath 文件路径
 * @returns {Promise<boolean>} 是否存在
 */
async function checkFileExists(filePath) {
  // 浏览器环境下使用动态导入检查
  try {
    // 使用动态导入检查文件是否存在
    // 注意：实际项目中可能需要不同的方法
    await import(/* @vite-ignore */ filePath);
    return true;
  } catch (error) {
    // 导入失败可能是因为文件不存在或其他原因
    // 实际项目中可能需要更精确的判断
    return false;
  }
}

/**
 * 添加新组件
 * @param {string} path 组件路径
 * @param {Object} options 组件选项
 * @returns {Promise<boolean>} 是否成功
 */
export async function addNewComponent(path, options) {
  try {
    // 验证组件目录结构
    const validation = await validateComponentDirectory(path);
    if (!validation.valid) {
      ElMessage.error(validation.message);
      return false;
    }
    
    // 记录组件是否支持SSR
    const supportsSSR = validation.hasSSRExport;
    console.log(`[ComponentScanner] 组件 ${options.name || path} ${supportsSSR ? '支持' : '不支持'}SSR导出`);
    
    // 重新扫描组件映射表
    const success = await scanAndRegisterComponents();
    if (success) {
      ElMessage.success(`组件 ${options.name || path} 添加成功${supportsSSR ? '，支持SSR导出' : ''}`);
    }
    
    return success;
  } catch (error) {
    ElMessage.error(`添加组件失败: ${error.message}`);
    console.error('[ComponentScanner] 添加组件失败:', error);
    return false;
  }
}

/**
 * 检查组件是否支持SSR导出
 * @param {string} componentType 组件类型
 * @returns {Promise<boolean>} 是否支持SSR导出
 */
export async function checkComponentSupportsSSR(componentType) {
  try {
    const componentPath = autoComponentLoader.resolveComponentPath(componentType);
    if (!componentPath) return false;
    
    try {
      // 尝试导入SSR导出文件
      await import(/* @vite-ignore */ `../components/library/${componentPath}/export.ssr.js`);
      return true;
    } catch (e) {
      return false;
    }
  } catch (error) {
    console.error(`[ComponentScanner] 检查组件SSR支持失败: ${componentType}`, error);
    return false;
  }
}

/**
 * 获取组件路径映射
 * @returns {Object} 组件路径映射
 */
export function getComponentPathMapping() {
  const mapping = {};
  
  if (!autoComponentLoader.initialized) {
    console.warn('[ComponentScanner] 组件加载器未初始化，无法获取路径映射');
    return mapping;
  }
  
  // 从AutoComponentLoader获取路径映射
  for (const [type, path] of Object.entries(autoComponentLoader.componentPaths)) {
    mapping[type] = path;
  }
  
  return mapping;
}

// 导出扫描和注册功能
export default {
  scanAndRegisterComponents,
  validateComponentDirectory,
  addNewComponent,
  checkComponentSupportsSSR,
  getComponentPathMapping,
  componentScanStatus
}; 